home *** CD-ROM | disk | FTP | other *** search
/ SPACE 2 / SPACE - Library 2 - Volume 1.iso / utility / 329 / xblit.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-10-18  |  4.6 KB  |  272 lines
  1.  
  2. #include <stdio.h>
  3. #include <osbind.h>
  4.  
  5. /***************************************************************************
  6.  
  7.     XBLIT.C
  8.  
  9.     - block memory move routines
  10.  
  11.     09/05/87 created
  12.  
  13.     03/07/88 15:30
  14.  
  15. ***************************************************************************/
  16.  
  17. char *_blit(qfrom, qto)
  18. register char *qfrom, *qto;
  19.     {
  20.     asm
  21.         {
  22.     lblit:
  23.         move.b  (qfrom)+,(qto)+ ; transfer a byte
  24.         bne   lblit         ; until a zero
  25.         }
  26.     return qto-1;
  27.     }
  28.  
  29. char *_blitb(qfrom, qto, cb)
  30. register char *qfrom, *qto;
  31. register int cb;
  32.     {
  33.     asm
  34.         {
  35.         cmpa  qfrom,qto   ; if source < dest
  36.         bcc   blitbup     ; then go copy backwards
  37.  
  38.         subi.w  #1,cb     ; check if cb==0
  39.         bcs   eblitb      ; yes, get out
  40.  
  41.     lblitb:
  42.         move.b  (qfrom)+,(qto)+
  43.         dbf   cb,lblitb
  44.         bra   eblitb
  45.  
  46.     blitbup:
  47.         adda.w  cb,qfrom    ; pointers point to ends of blocks
  48.         adda.w  cb,qto
  49.         move.l  qto,A1      ; return value
  50.  
  51.         subi.w  #1,cb     ; check if cb==0
  52.         bcs   eblitb
  53.  
  54.     lblitbup:
  55.         move.b  -(qfrom),-(qto)
  56.         dbf   cb,lblitbup
  57.         move.l  A1,qto      ; return value
  58.  
  59.     eblitb:
  60.         nop
  61.         }
  62.     return qto;
  63.     }
  64.  
  65.  
  66. char *_blitbz(qfrom, qto, cb)
  67. register char *qfrom, *qto;
  68. register int cb;
  69.     {
  70.     asm
  71.         {
  72.         subi.w  #1,cb
  73.         bcs   eblitbz  
  74.     lblitbz:
  75.         move.b  (qfrom)+,(qto)+
  76.         dbf   cb,lblitbz
  77.     eblitbz:
  78.         clr.b (qto)
  79.         }
  80.     return qto;
  81.     }
  82.  
  83. int *_blitw(qfrom, qto, cw)
  84. register int *qfrom, *qto;
  85. register int cw;
  86.     {
  87.     asm
  88.         {
  89.         subi.w  #1,cw
  90.         bcs   eblitw  
  91.     lblitw:
  92.         move.w  (qfrom)+,(qto)+
  93.         dbf   cw,lblitw
  94.     eblitw:
  95.         nop
  96.         }
  97.     return qto;
  98.     }
  99.  
  100.  
  101. int *_blitwz(qfrom, qto, cw)
  102. register int *qfrom, *qto;
  103. register int cw;
  104.     {
  105.     asm
  106.         {
  107.         subi.w  #1,cw
  108.         bcs   eblitwz  
  109.     lblitwz:
  110.         move.w  (qfrom)+,(qto)+
  111.         dbf   cw,lblitwz
  112.     eblitwz:
  113.         clr.b (qto)
  114.         }
  115.     return qto;
  116.     }
  117.  
  118. long *_blitl(qfrom, qto, cl)
  119. register long *qfrom, *qto;
  120. register int cl;
  121.     {
  122.     asm
  123.         {
  124.         subi.w  #1,cl
  125.         bcs   eblitl  
  126.     lblitl:
  127.         move.l  (qfrom)+,(qto)+
  128.         dbf   cl,lblitl
  129.     eblitl:
  130.         nop
  131.         }
  132.     return qto;
  133.     }
  134.  
  135.  
  136. long *_blitlz(qfrom, qto, cl)
  137. register long *qfrom, *qto;
  138. register int cl;
  139.     {
  140.     asm
  141.         {
  142.         subi.w  #1,cl
  143.         bcs   eblitlz  
  144.     lblitlz:
  145.         move.l  (qfrom)+,(qto)+
  146.         dbf   cl,lblitlz
  147.     eblitlz:
  148.         clr.b (qto)
  149.         }
  150.     return qto;
  151.     }
  152.  
  153. char *_blitc(ch, qto, cb)
  154. register char *qto;
  155. register int ch, cb;
  156.     {
  157.     asm
  158.         {
  159.         subi.w  #1,cb
  160.         bcs   eblitc  
  161.         
  162.     lblitc:
  163.         move.b  ch,(qto)+
  164.         dbf   cb,lblitc
  165.     eblitc:
  166.         nop
  167.         }
  168.     return qto;
  169.     }
  170.  
  171. char *_blitcz(ch, qto, cb)
  172. register char *qto;
  173. register int ch, cb;
  174.     {
  175.     asm
  176.         {
  177.         subi.w  #1,cb
  178.         bcs   eblitbz  
  179.     lblitcz:
  180.         move.b  ch,(qto)+
  181.         dbf   cb,lblitcz
  182.     eblitbz:
  183.         clr.b (qto)
  184.         }
  185.     return qto;
  186.     }
  187.  
  188. char *_blitzb(qto, cb)
  189. register char *qto;
  190. register int cb;
  191.     {
  192.     asm
  193.         {
  194.         subi.w  #1,cb
  195.         bcs   eblitzb  
  196.     lblitzb:
  197.         clr.b (qto)+
  198.         dbf   cb,lblitzb
  199.     eblitzb:
  200.         nop
  201.         }
  202.     return qto;
  203.     }
  204.  
  205. int *_blitzw(qto, cw)
  206. register int *qto;
  207. register int cw;
  208.     {
  209.     asm
  210.         {
  211.         subi.w  #1,cw
  212.         bcs   eblitzw  
  213.     lblitzw:
  214.         clr.w (qto)+
  215.         dbf   cw,lblitzw
  216.     eblitzw:
  217.         nop
  218.         }
  219.     return qto;
  220.     }
  221.  
  222. long *_blitzl(qto, cl)
  223. register long *qto;
  224. register int cl;
  225.     {
  226.     asm
  227.         {
  228.         subi.w  #1,cl
  229.         bcs   eblitzl  
  230.     lblitzl:
  231.         clr.l (qto)+
  232.         dbf   cl,lblitzl
  233.     eblitzl:
  234.         nop
  235.         }
  236.     return qto;
  237.     }
  238.  
  239. long *_blitcls(qto)
  240. register long *qto;
  241.     {
  242.     asm
  243.         {
  244.         move.w  #1999,D0 
  245.     lblitcls:
  246.         clr.l (qto)+
  247.         clr.l (qto)+
  248.         clr.l (qto)+
  249.         clr.l (qto)+
  250.         dbf   D0,lblitcls
  251.         }
  252.     return qto;
  253.     }
  254.  
  255. long *_blitscr(qfrom,qto)
  256. register long *qfrom,*qto;
  257.     {
  258.     asm
  259.         {
  260.         move.w  #1999,D0 
  261.     lblitscr:
  262.         move.l  (qfrom)+,(qto)+
  263.         move.l  (qfrom)+,(qto)+
  264.         move.l  (qfrom)+,(qto)+
  265.         move.l  (qfrom)+,(qto)+
  266.         dbf   D0,lblitscr
  267.         }
  268.     return qto;
  269.     }
  270.  
  271.  
  272.